How to Integrate the Justimmo API Into Your Website: A Practical Guide

The Justimmo API docs tell you what the endpoints do. This guide tells you how to actually use them. Authentication, fetching listings, filtering, handling the XML response, and displaying properties on your website.

What the Official Docs Do Not Tell You

Justimmo publishes API documentation that covers every endpoint, every parameter, and every response field. What it does not cover is the practical side: how to set up authentication cleanly, how to structure your integration, what to watch out for when displaying listings, and how the API fits into a real website build.

This guide fills that gap. It assumes you are a developer building a real estate website for an agency that uses Justimmo as their CRM, and you need to display their listings — either on a custom site or integrated with an existing one.

What the Justimmo API Actually Is

Justimmo is a real estate CRM and management platform used primarily by Austrian real estate agencies. The API is an HTTP REST interface that exposes the property data stored in a Justimmo account — listings, projects, contacts, and reference data like property types, features, and locations.

The key things to understand before you start:

• The API is per-account, not public. Each agency has their own Justimmo account. The API credentials belong to that account, not to Justimmo globally.
• Properties must be booked into the API feed. A listing does not appear in the API just because it exists in Justimmo — the agency needs to explicitly enable API export for each property in their Justimmo settings.
• The API returns XML by default. Not JSON. Some endpoints support JSON, but the primary format is XML loosely based on the OpenImmo 1.2.7 standard.
• Authentication is HTTP Basic Auth. Username and password are provided under the API export settings inside the Justimmo admin.

Getting Your Credentials

Log into Justimmo, navigate to Settings, then Exports, then API. Enable the API export and note the username and password provided. These are separate from the Justimmo login credentials — they are specific to the API export.

The base URL for all API calls is:

https://api.justimmo.at/rest/v1/

Every request must include HTTP Basic Auth headers. There is no token-based auth, no OAuth — just username and password on every request.

Using the PHP SDK

Justimmo maintains an official PHP SDK that wraps the API. If you are building on PHP or Laravel, use it — it handles authentication, XML parsing, and object mapping so you do not have to.

Install via Composer:

composer require justimmo/php-sdk

Basic setup and fetching listings:

use Justimmo\Api\JustimmoApi;
use Justimmo\Model\RealtyQuery;
use Justimmo\Model\Wrapper\V1\RealtyWrapper;
use Justimmo\Model\Mapper\V1\RealtyMapper;
use Justimmo\Cache\NullCache;

$api = new JustimmoApi('your-api-username', 'your-api-password');
$mapper = new RealtyMapper();
$wrapper = new RealtyWrapper($mapper);
$query = new RealtyQuery($api, $wrapper, $mapper);

$realties = $query
    ->filterByPrice(['min' => 500, 'max' => 2000])
    ->filterByZipCode(1020)
    ->orderBy('price', 'asc')
    ->find();

foreach ($realties as $realty) {
    echo $realty->getTitle() . ' - ' . $realty->getPrice();
}

The SDK returns typed objects — so you get getTitle(), getPrice(), getRooms(), getArea(), etc., instead of parsing raw XML yourself.

Fetching a Single Property

For a property detail page, you will want the full detail object for a single listing:

$realty = $query->findOneById(123456);

This returns the detailed XML response for that property, parsed into the RealtyMapper object. It includes description fields, room details, equipment/features, pictures, and agent contact information.

Getting pictures:

foreach ($realty->getAttachments() as $attachment) {
    if ($attachment->isImage()) {
        echo $attachment->getUrl('big');
    }
}

Picture sizes available: small, medium, big, quadratic. Always request the size you need rather than downloading large images and resizing them server-side.

Common Filter Parameters

The API supports a wide range of filters. Here are the ones you will use most often:

You can also filter by keyword (must appear in title or description), by property status, and by updated date — useful for syncing only changed listings rather than fetching everything on every request.

Handling Pagination

The API returns a maximum of 100 results per request. For agencies with large portfolios, you will need to paginate:

$query
    ->limit(10)
    ->offset(0)  // First page
    ->find();

// For page 2:
$query
    ->limit(10)
    ->offset(10)
    ->find();

The response includes a total count in the query-result element, so you can calculate the number of pages and build pagination controls accordingly.

Submitting Enquiries

The API also handles contact/enquiry submissions — so instead of building a separate contact form system, you can post enquiries directly into Justimmo and the property’s assigned agent receives the notification.

// Direct HTTP call — SDK does not wrap this endpoint
$url = 'https://api.justimmo.at/rest/v1/objekt/anfrage';
$params = [
    'objekt_id' => 123456,
    'vorname'   => 'Max',
    'nachname'  => 'Mustermann',
    'email'     => 'max@example.com',
    'tel'       => '+43 1 234 567',
    'message'   => 'I am interested in this property.'
];

// POST with Basic Auth headers

A 200 response means the enquiry was created and the contact was added to Justimmo. You can also pass newsletter category IDs and handle double opt-in either externally or let Justimmo handle it automatically.

Connecting to immo.at

immo.at is Austria’s largest property portal. Justimmo has a built-in immo.at export — you enable it in the Justimmo export settings, not through the API. Once enabled, listings booked into the immo.at export are automatically syndicated to the portal on Justimmo’s regular sync schedule.

What the API adds on top of this: you can use the updated_at filter to detect which listings have changed since your last sync, so your own website stays in sync with what is live on immo.at without doing a full re-fetch every time.

$realties = $query
    ->filterByUpdatedAt(['from' => '2025-01-01'])
    ->find();

What to Cache and What Not to Cache

The Justimmo API does not have generous rate limits, and fetching the full detail for every listing on every page load will cause problems at scale. Cache aggressively:

• Reference data (property types, federal states, equipment lists) — cache for 24 hours minimum. This data almost never changes.
• Listing lists (search results, homepage featured listings) — cache for 15–60 minutes depending on how frequently the agency updates their listings.
• Individual listing detail — cache for 30 minutes. Use the listing ID as the cache key.
• Do not cache enquiry submissions. These need to go to the API in real time.

The SDK accepts a cache implementation in its constructor. If you are using Laravel, inject a PSR-16 compatible cache adapter.

Justimmo and WordPress

There is no official Justimmo WordPress plugin, and the third-party options available are limited in scope. Most WordPress integrations for Justimmo are either custom-built or based on thin wrappers around the API.

If you are building on WordPress, the most reliable approach is to create a custom plugin that uses the PHP SDK (or direct HTTP calls via wp_remote_get) and stores listing data as a custom post type. This gives you full control over the display, search, and filtering experience, and avoids the limitations of generic plugin solutions.

The alternative — querying the Justimmo API on every page load without caching — will eventually cause timeout issues and a poor user experience, particularly on listing search pages where you are filtering across potentially large datasets.

Common Integration Mistakes

• Forgetting to enable the API export in Justimmo settings. The most common reason integrations return empty results. The API is an export type — listings have to be explicitly assigned to it.
• Not handling the picture size parameter. If you do not specify a size, you get whatever the default returns, which is often larger than you need.
• Parsing the XML yourself instead of using the SDK. The XML structure is not always consistent. The SDK handles edge cases you will not think of until production.
• No caching layer. Fine for development, a problem in production.
• Hardcoding the credentials. Use environment variables. The API credentials will need to be rotated occasionally.

Need Help With Your Justimmo Integration?

If you are building a website that needs to display and manage Justimmo listings — whether that is a custom Laravel application, a WordPress integration, or something connected to immo.at — I build and maintain these integrations. The scope usually covers API setup, caching, listing display, search and filtering, enquiry handling, and ongoing maintenance as Justimmo makes API changes.

Get in touch if you want to talk through your specific requirements.